{ "cells": [ { "cell_type": "markdown", "id": "c04e3ac9", "metadata": {}, "source": [ "# Differential equation resolution\n", "\n", "## Introduction\n", "\n", "We present here a Perceval implementation of a Quantum Machine Learning algorithm for solving differential equations. Its aims is to approximate the solution to the differential equation considered in \\[1\\]:\n", "\n", "$$\n", "\\frac{d f}{d x}+\\lambda f(x)(\\kappa+\\tan (\\lambda x))=0\n", "$$\n", "\n", "with boundary condition $f(0)=f_{0}$. The analytical solution is $f(x)=f_0\\exp (-\\kappa \\lambda x) \\cos (\\lambda x)$.\n", "\n", "### QML Loss Function Definition\n", "\n", "In order to use QML to solve this differential equation, we first need to derive from it a loss function whose minimum is associated to its analytical solution.\n", "\n", "Let $F\\left[\\left\\{d^{m} f / d x^{m}\\right\\}_{m},f, x\\right]=0$ be a general differential equation verified by $f(x)$, where $F[.]$ is an operator acting on $f(x)$, its derivatives and $x$. For the solving of a differential equation, the loss function described in \\[1\\] consists of two terms\n", "\n", "$$\n", " \\mathcal{L}_{\\boldsymbol{\\theta}}\\left[\\left\\{d^{m} g / d x^{m}\\right\\}_{m},g, x\\right]:=\\mathcal{L}_{\\boldsymbol{\\theta}}^{(\\mathrm{diff})}\\left[\\left\\{d^{m} g / d x^{m}\\right\\}_{m},g, x\\right]+\\mathcal{L}_{\\boldsymbol{\\theta}}^{(\\text {boundary})}[g, x].\n", "$$\n", "\n", "The first term $\\mathcal{L}_{\\boldsymbol{\\theta}}^{(\\mathrm{diff})}$ corresponds to the differential equation which has been discretised over a fixed regular grid of $M$ points noted $x_i$:\n", "\n", "$$\n", " \\mathcal{L}_{\\boldsymbol{\\theta}}^{(\\mathrm{diff})}\\left[\\left\\{d^{m} g / d x^{m}\\right\\}_{m},g, x\\right]:=\\frac{1}{M} \\sum_{i=1}^{M} L\\left(F\\left[d_{x}^m g\\left(x_{i}\\right), g\\left(x_{i}\\right), x_{i}\\right], 0\\right),\n", "$$\n", "\n", "where $L(a,b) := (a - b)^2$ is the squared distance between two arguments. The second term $\\mathcal{L}_{\\boldsymbol{\\theta}}^{(\\text {boundary })}$ is associated to the initial conditions of our desired solution. It is defined as: \n", "\n", "$$\n", " \\mathcal{L}_{\\boldsymbol{\\theta}}^{\\text {(boundary) }}[g, x]:=\\eta L\\left(g(x_0), f_{0}\\right),\n", "$$\n", " \n", "where $\\eta$ is the weight granted to the boundary condition and $f_{0}$ is given by $f(x_0) = f_0$. \n", "\n", "Given a function approximator $f^{(n)}(x, \\boldsymbol{\\theta}, \\boldsymbol{\\lambda})$, the loss function above will be minimised using a classical algorithm, updating the parameters $\\boldsymbol{\\theta}$ based on samples obtained using a quantum device.\n", "\n", "### Quantum circuit architecture\n", "\n", "The feature map used is presented in \\[2,3,4\\]. The quantum circuit architecture from \\[4\\] is expressed as $\\mathcal{U}(x, \\boldsymbol{\\theta}):=\\mathcal{W}^{(2)}\\left(\\boldsymbol{\\theta}_{2}\\right) \\mathcal{S}(x) \\mathcal{W}^{(1)}\\left(\\boldsymbol{\\theta}_{1}\\right).$ The phase-shift operator $\\mathcal{S}(x)$ incorporates the $x$ dependency of the function we wish to approximate. It is sandwiched between two universal interferometers $\\mathcal{W}^{(1)}(\\boldsymbol{\\theta_1})$ and $\\mathcal{W}^{(2)}(\\boldsymbol{\\theta_2})$, where the beam-splitter parameters $\\boldsymbol{\\theta_1}$ and $\\boldsymbol{\\theta_2}$ of this mesh architecture are tunable to enable training of the circuit.\n", "The output measurement operator, noted $\\mathcal{M}(\\boldsymbol{\\lambda})$, is the projection on the Fock states obtained using photon-number resolving detectors, multiplied by some coefficients $\\boldsymbol{\\lambda}$ which can also be tunable. Formally, we have:\n", "\n", "$$ \\mathcal{M}(\\boldsymbol{\\lambda}) = \\sum_{\\mathbf{\\left | n^{(f)}\\right \\rangle}}\\lambda_{\\mathbf{\\left | n^{(f)}\\right \\rangle}}\\mathbf{\\left | n^{(f)}\\right \\rangle}\\mathbf{\\left \\langle n^{(f)}\\right |},\n", "$$\n", "\n", "where the sum is taken over all $\\binom{n+m-1}{n}$ possible Fock states considering $n$ photons in $m$ modes. Let $\\mathbf{\\left | n^{(i)}\\right \\rangle} = \\left |n^{(i)}_1,n^{(i)}_2,\\dots,n^{(i)}_m\\right \\rangle$ be the input state consisting of $n$ photons where $n^{(i)}_j$ is the number of photons in input mode $j$. Given these elements, the circuit's output $f^{(n)}(x, \\boldsymbol{\\theta}, \\boldsymbol{\\lambda})$ is given by the following expectation value:\n", "\n", "$$\n", "f^{(n)}(x, \\boldsymbol{\\theta}, \\boldsymbol{\\lambda})=\\left\\langle\\mathbf{n}^{(i)}\\left|\\mathcal{U}^{\\dagger}(x, \\boldsymbol{\\theta}) \\mathcal{M}(\\boldsymbol{\\lambda}) \\mathcal{U}(x, \\boldsymbol{\\theta})\\right| \\mathbf{n}^{(i)}\\right\\rangle.\n", "$$\n", "\n", "This expression can be rewritten as the following Fourier series \\[4\\]\n", "\n", "$$\n", "f^{(n)}(x, \\boldsymbol{\\theta}, \\boldsymbol{\\lambda})=\\sum_{\\omega \\in \\Omega_{n}} c_{\\omega}(\\boldsymbol{\\theta}, \\boldsymbol{\\lambda}) e^{i \\omega x},\n", "$$\n", "\n", "where $\\Omega_n = \\{-n, -n+1, \\dots, n-1, n \\}$ is the frequency spectrum one can reach with $n$ incoming photons and $\\{c_\\omega(\\boldsymbol{\\theta}, \\boldsymbol{\\lambda})\\}$ are the Fourier coefficients. The $\\boldsymbol{\\lambda}$ parameters are sampled randomly in the interval $[-a;a]$, with $a$ a randomly chosen integer. $f^{(n)}(x, \\boldsymbol{\\theta}, \\boldsymbol{\\lambda})$ will serve as a function approximator for this chosen differential equation. Differentiation in the loss function is discretised as $\\frac{df}{dx} \\simeq \\frac{f(x+\\Delta x) - f(x-\\Delta x)}{2\\Delta x}$.\n", "\n", "$n, m,$ and $\\boldsymbol{\\lambda}$ are variable parameters defined below. $\\Delta x$ is the mesh size." ] }, { "cell_type": "markdown", "id": "e9df16c8", "metadata": {}, "source": [ "## Perceval Simulation\n", "\n", "### Initialisation" ] }, { "cell_type": "code", "execution_count": 1, "id": "7918962c", "metadata": {}, "outputs": [], "source": [ "import perceval as pcvl\n", "import numpy as np\n", "from math import comb\n", "from scipy.optimize import minimize\n", "import time\n", "import matplotlib.pyplot as plt\n", "import matplotlib as mpl\n", "import tqdm as tqdm" ] }, { "cell_type": "markdown", "id": "04323b71", "metadata": {}, "source": [ "We will run this notebook with 4 photons. We could use more photons, but the result with 4 photons is already satisfying." ] }, { "cell_type": "code", "execution_count": 2, "id": "f59b62f8", "metadata": {}, "outputs": [], "source": [ "nphotons = 4" ] }, { "cell_type": "markdown", "id": "bd3c3eaf", "metadata": {}, "source": [ "### Differential equation parameters\n", "\n", "We define here the value of the differential equation parameters and boundary condition $\\lambda, \\kappa, f_0$." ] }, { "cell_type": "code", "execution_count": 3, "id": "debd15cc", "metadata": {}, "outputs": [], "source": [ "# Differential equation parameters\n", "lambd = 8\n", "kappa = 0.1\n", "\n", "def F(u_prime, u, x): # DE, works with numpy arrays\n", " return u_prime + lambd * u * (kappa + np.tan(lambd * x))" ] }, { "cell_type": "code", "execution_count": 4, "id": "4c18efbf", "metadata": {}, "outputs": [], "source": [ "# Boundary condition (f(x_0)=f_0)\n", "x_0 = 0\n", "f_0 = 1" ] }, { "cell_type": "code", "execution_count": 5, "id": "ac67fd52", "metadata": {}, "outputs": [], "source": [ "# Modeling parameters\n", "n_grid = 50 # number of grid points of the discretized differential equation\n", "range_min = 0 # minimum of the interval on which we wish to approximate our function\n", "range_max = 1 # maximum of the interval on which we wish to approximate our function\n", "X = np.linspace(range_min, range_max-range_min, n_grid) # Optimisation grid" ] }, { "cell_type": "code", "execution_count": 6, "id": "45a02405", "metadata": {}, "outputs": [], "source": [ "# Differential equation's exact solution - for comparison\n", "def u(x):\n", " return np.exp(- kappa*lambd*x)*np.cos(lambd*x)" ] }, { "cell_type": "code", "execution_count": 7, "id": "9c8830ee", "metadata": {}, "outputs": [], "source": [ "# Parameters of the quantum machine learning procedure\n", "N = nphotons # Number of photons\n", "m = nphotons # Number of modes\n", "eta = 5 # weight granted to the initial condition\n", "a = 200 # Approximate boundaries of the interval that the image of the trial function can cover\n", "fock_dim = comb(N + m - 1, N)\n", "# lambda coefficients for all the possible outputs\n", "lambda_random = 2 * a * np.random.rand(fock_dim) - a\n", "# dx serves for the numerical differentiation of f\n", "dx = (range_max-range_min) / (n_grid - 1)" ] }, { "cell_type": "code", "execution_count": 8, "id": "355b87c8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "|1,1,1,1>\n" ] } ], "source": [ "# Input state with N photons and m modes\n", "input_state = pcvl.BasicState([1]*N+[0]*(m-N))\n", "print(input_state)" ] }, { "cell_type": "markdown", "id": "58385605", "metadata": {}, "source": [ "## Definition of the circuit\n", "\n", "We will generate a Haar-random initial unitary using QR decomposition built in Perceval `Matrix.random_unitary`, the circuit is defined by the combination of 3 sub-circuits - the intermediate phase is a parameter." ] }, { "cell_type": "code", "execution_count": 9, "id": "5dd4d6c3", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "W1\n", "\n", "\n", "Φ=px\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "W2\n", "\n", "\n", "\n", "\n", "0\n", "1\n", "2\n", "3\n", "0\n", "1\n", "2\n", "3\n", "" ], "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"Haar unitary parameters\"\n", "# number of parameters used for the two universal interferometers (2*m**2 per interferometer)\n", "parameters = np.random.normal(size=4*m**2)\n", "\n", "px = pcvl.P(\"px\")\n", "c = pcvl.Unitary(pcvl.Matrix.random_unitary(m, parameters[:2 * m ** 2]), name=\"W1\")\\\n", " // (0, pcvl.PS(px))\\\n", " // pcvl.Unitary(pcvl.Matrix.random_unitary(m, parameters[2 * m ** 2:]), name=\"W2\")\n", "\n", "backend = pcvl.BackendFactory().get_backend(\"SLOS\")\n", "backend.set_circuit(pcvl.Unitary(pcvl.Matrix.random_unitary(m)))\n", "backend.preprocess([input_state])\n", "\n", "pcvl.pdisplay(c)" ] }, { "cell_type": "markdown", "id": "5d9333b0", "metadata": {}, "source": [ "### Expectation value and loss function computation\n", "\n", "The expectation value of the measurement operator $\\mathcal{M}(\\boldsymbol{\\lambda})$ is obtained directly from Fock state probabilities computed by Perceval. Given this expectation value, the code snippet below computes the loss function defined in the Introduction.\n", "\n", "Note the use of the `all_prob` simulator method giving directly access to the probabilities of all possible output states, including null probabilities. This calculation is optimized in SLOS backend." ] }, { "cell_type": "code", "execution_count": 10, "id": "597cce98", "metadata": {}, "outputs": [], "source": [ "def computation(params):\n", " global current_loss\n", " global computation_count\n", " \"compute the loss function of a given differential equation in order for it to be optimized\"\n", " computation_count += 1\n", " f_theta_0 = 0 # boundary condition\n", " coefs = lambda_random # coefficients of the M observable\n", " # initial condition with the two universal interferometers and the phase shift in the middle\n", " U_1 = pcvl.Matrix.random_unitary(m, params[:2 * m ** 2])\n", " U_2 = pcvl.Matrix.random_unitary(m, params[2 * m ** 2:])\n", "\n", " px = pcvl.P(\"x\")\n", " c = pcvl.Unitary(U_2) // (0, pcvl.PS(px)) // pcvl.Unitary(U_1)\n", "\n", " px.set_value(np.pi * x_0)\n", " backend.set_circuit(c)\n", " f_theta_0 = np.sum(np.multiply(backend.all_prob(input_state), coefs))\n", "\n", " # boundary condition given a weight eta\n", " loss = eta * (f_theta_0 - f_0) ** 2 * len(X)\n", "\n", " # Y[0] is before the domain we are interested in (used for differentiation), x_0 is at Y[1]\n", " Y = np.zeros(n_grid + 2)\n", "\n", " # x_0 is at the beginning of the domain, already calculated\n", " Y[1] = f_theta_0\n", "\n", " px.set_value(np.pi * (range_min - dx))\n", " backend.set_circuit(c)\n", " Y[0] = np.sum(np.multiply(backend.all_prob(input_state), coefs))\n", "\n", "\n", " for i in range(1, n_grid):\n", " x = X[i]\n", " px.set_value(np.pi * x)\n", " backend.set_circuit(c)\n", " Y[i + 1] = np.sum(np.multiply(backend.all_prob(input_state), coefs))\n", "\n", " px.set_value(np.pi * (range_max + dx))\n", " backend.set_circuit(c)\n", " Y[n_grid + 1] = np.sum(np.multiply(backend.all_prob(input_state), coefs))\n", "\n", " # Differentiation\n", " Y_prime = (Y[2:] - Y[:-2])/(2*dx)\n", "\n", " loss += np.sum((F(Y_prime, Y[1:-1], X))**2)\n", "\n", " current_loss = loss / len(X)\n", " return current_loss" ] }, { "cell_type": "markdown", "id": "8acf5506", "metadata": {}, "source": [ "### Classical optimisation\n", "\n", "Finally the code below performs the optimisation procedure using the loss function defined in the previous section. To this end, we use a Broyden–Fletcher–Goldfarb–Shanno (BFGS) optimiser \\[5\\] from the SciPy library." ] }, { "cell_type": "code", "execution_count": 11, "id": "281dbb29", "metadata": {}, "outputs": [], "source": [ "def callbackF(parameters):\n", " \"\"\"callback function called by scipy.optimize.minimize allowing to monitor progress\"\"\"\n", " global current_loss\n", " global computation_count\n", " global loss_evolution\n", " global start_time\n", " now = time.time()\n", " pbar.set_description(\"M= %d Loss: %0.5f #computations: %d elapsed: %0.5f\" % \n", " (m, current_loss, computation_count, now-start_time))\n", " pbar.update(1)\n", " loss_evolution.append((current_loss, now-start_time))\n", " computation_count = 0\n", " start_time = now" ] }, { "cell_type": "code", "execution_count": 12, "id": "465db5d2", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "M= 4 Loss: 0.00866 #computations: 130 elapsed: 2.49080: : 105it [03:06, 1.63s/it] " ] } ], "source": [ "computation_count = 0\n", "current_loss = 0\n", "start_time = time.time()\n", "loss_evolution = []\n", "\n", "pbar = tqdm.tqdm()\n", "res = minimize(computation, parameters, callback=callbackF, method='BFGS', options={'gtol': 1E-2})" ] }, { "cell_type": "markdown", "id": "1be681a8", "metadata": {}, "source": [ "After the optimisation procedure has been completed, the optimal unitary parameters (in `res.x`) can be used to determine the quantum circuit beam-splitter and phase-shifter angles for an experimental realisation." ] }, { "cell_type": "code", "execution_count": 13, "id": "21726b0c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Unitary parameters [-0.66334127 -0.04353921 -1.92172598 1.46311582 0.13834699 0.04840466\n", " -1.92475716 0.94111392 0.04711636 1.6339162 1.56303605 -0.36947264\n", " -0.88242141 0.63431897 -0.71258671 1.11715881 0.21961878 -0.32474614\n", " 0.96963211 0.25191156 -0.27099778 -1.41618548 2.5426048 -0.14291888\n", " 0.3290805 0.67119072 -1.54546836 1.43350362 0.44816853 -1.37555405\n", " -0.46218774 1.05279649 0.90589211 -1.15132551 -0.48436678 0.10585881\n", " -0.02193175 -0.80538581 -0.36660846 1.72574933 -0.05184236 -1.1402877\n", " 0.86127372 0.25229208 -0.15104874 -0.36761966 -0.56477874 1.2582815\n", " -0.17414877 -1.20035746 0.67259315 -1.11251674 0.0161855 1.17097977\n", " -1.0474133 1.0467571 -0.10005266 -0.71137126 1.03264364 -1.02637915\n", " -0.04809381 -1.00089775 -0.78788374 -0.49447837]\n" ] } ], "source": [ "print(\"Unitary parameters\", res.x)" ] }, { "cell_type": "markdown", "id": "3b6c5da8", "metadata": {}, "source": [ "### Plotting the approximation\n", "\n", "We now plot the result of our optimisation in order to compare the QML algorithm's output and the analytical solution." ] }, { "cell_type": "code", "execution_count": 14, "id": "6bede765", "metadata": {}, "outputs": [], "source": [ "def plot_solution(m, N, X, optim_params, lambda_random):\n", " Y = []\n", " U_1 = pcvl.Matrix.random_unitary(m, optim_params[:2 * m ** 2])\n", " U_2 = pcvl.Matrix.random_unitary(m, optim_params[2 * m ** 2:])\n", " px = pcvl.P(\"x\")\n", " c = pcvl.Unitary(U_2) // (0, pcvl.PS(px)) // pcvl.Unitary(U_1)\n", "\n", " for x in X:\n", " px.set_value(np.pi * x)\n", " backend.set_circuit(c)\n", " f_theta = np.sum(np.multiply(backend.all_prob(input_state), lambda_random))\n", " Y.append(f_theta)\n", " exact = u(X)\n", " plt.plot(X, Y, label=\"Approximation with {} photons\".format(N))" ] }, { "cell_type": "code", "execution_count": 15, "id": "b997c635", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "X = np.linspace(range_min, range_max, 200)\n", "\n", "# Change the plot size\n", "default_figsize = mpl.rcParamsDefault['figure.figsize']\n", "mpl.rcParams['figure.figsize'] = [2 * value for value in default_figsize]\n", "\n", "plot_solution(m, N, X, res.x, lambda_random)\n", "\n", "plt.plot(X, u(X), 'r', label='Analytical solution')\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 16, "id": "f819bb4b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Loss function value')" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot([v[0] for v in loss_evolution])\n", "plt.yscale(\"log\")\n", "plt.xlabel(\"Number of epochs\")\n", "plt.ylabel(\"Loss function value\")" ] }, { "cell_type": "markdown", "id": "e53fa645", "metadata": {}, "source": [ "## References\n", "\n", "> [1] O. Kyriienko, A. E. Paine, and V. E. Elfving, “Solving nonlinear differential equations with differentiable quantum circuits”, [Physical Review A](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.103.052416) **103**, 052416 (2021).\n", "\n", "> [2] A. Pérez-Salinas, A. Cervera-Lierta, E. Gil-Fuster, and J. I. Latorre, “Data re-uploading for a universal quantum classifier”, [Quantum](https://quantum-journal.org/papers/q-2020-02-06-226/) **4**, 226 (2020).\n", "\n", "> [3] M. Schuld, R. Sweke, and J. J. Meyer, “Effect of data encoding on the expressive power of variational quantum-machine-learning models”, [Physical Review A]( https://journals.aps.org/pra/abstract/10.1103/PhysRevA.103.032430) **103**, 032430 (2021).\n", "\n", "> [4] B. Y. Gan, D. Leykam, D. G. Angelakis, and D. G. Angelakis, “Fock State-enhanced Expressivity of Quantum Machine Learning Models”, in [Conference on Lasers andElectro-Optics](https://opg.optica.org/abstract.cfm?uri=CLEO_AT-2021-JW1A.73) (2021), paper JW1A.73. Optica Publishing Group, (2021).\n", "\n", "> [5] R. Fletcher, Practical methods of optimization. [John Wiley & Sons](https://onlinelibrary.wiley.com/doi/book/10.1002/9781118723203). (2013)." ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }